{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ff5d8109",
   "metadata": {},
   "source": [
    "# Домашнее задание №5: \"Катастрофическое забывание\"\n",
    "\n",
    "В домашней работе необходимо показать в действии проблему \"катастрофического забывания\".\n",
    "\n",
    "**План для домашней работы:**\n",
    "- Обучить исходную модель на датасете Food101 и проверить ее качество\n",
    "- Дообучить модель на датасете STL10 с помощью Transfer Learning Fine-Tuning\n",
    "- Вернуть полносвязную сеть для датасета Food101 и проверить качество модели на данном датасете\n",
    "- Дообучить только полносвязный слой на Food101 и проверить удалось ли добиться исходного качества."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "11bd636d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import os\n",
    "import inspect \n",
    "\n",
    "import timm\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torchvision.datasets import STL10, Food101\n",
    "import torchvision.transforms as T\n",
    "from torch.utils.data import DataLoader\n",
    "from sklearn.metrics import accuracy_score\n",
    "import numpy as np\n",
    "from tqdm.notebook import tqdm\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint, TQDMProgressBar\n",
    "from torch import optim\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython import display"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "182b1510",
   "metadata": {},
   "source": [
    "## 1 Проверка качества исходной модели на датасете Food101\n",
    "\n",
    "Для проведения эксперимента вначале обучим модель с нуля на датасете Food101 до устойчивых показателей обучения (cross-entropy и accuracy).\n",
    "\n",
    "### 1.1 Создание вспомогательных классов\n",
    "#### 1.1.1 Функция подсчета accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b770f444",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_model_accuracy(model: torch.nn.Module, dataloader: torch.utils.data.DataLoader):\n",
    "    \"\"\" Подсчет Accuracy Score для модели\n",
    "    \n",
    "    Параметры\n",
    "    ---------\n",
    "    model: torch.nn.Module\n",
    "    dataloader : torch.utils.data.DataLoader\n",
    "      Загрузчик должен быть сформирован на базе класса imagenetlib.ImageNetteDataset\n",
    "      \n",
    "    Результат\n",
    "    ---------\n",
    "    accuracy_score : float\n",
    "    \"\"\"\n",
    "    \n",
    "    model.eval()\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    model = model.to(device)\n",
    "    batch_accuracy_list = []\n",
    "    for batch in tqdm(dataloader):\n",
    "        if isinstance(batch, dict):\n",
    "            image, target = batch['image'], batch['target']\n",
    "        else:\n",
    "            image, target = batch\n",
    "        image = image.to(device)\n",
    "        batch_predict = torch.argmax(model(image), axis=1)\n",
    "        batch_accuracy = accuracy_score(batch_predict.cpu(), target)\n",
    "        batch_accuracy_list.append(batch_accuracy)\n",
    "        \n",
    "    return np.mean(batch_accuracy_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b593fc64",
   "metadata": {},
   "source": [
    "#### 1.1.2 Класс для загрузки стандартных датасетов torchvision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "576edc0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class StandardTorchDataModule(pl.LightningDataModule):\n",
    "    \n",
    "    \"\"\" Загрузчик PyTorch Lighting для стандартных датасетов\n",
    "    из pytorchvision\n",
    "    \n",
    "    !!! Тестировался не со всеми классами\n",
    "    \n",
    "    Параметры\n",
    "    ---------\n",
    "    dataset_class : pytorch Dataset\n",
    "      Класс стандартного датасета из pytorchvision\n",
    "    train_loader_params : dict\n",
    "      Словарь для параметров DataLoader обучающего датасета.\n",
    "      Имеет следующие ключи:\n",
    "        - batch_size (по умолчанию 16)\n",
    "        - shuffle (по умолчанию True)\n",
    "        - num_workers (по умолчанию 2)\n",
    "        - drop_last (по умолчанию True)\n",
    "    val_loader_params : dict\n",
    "      Словарь для параметров DataLoader валидационного датасета.\n",
    "      Имеет следующие ключи:\n",
    "        - batch_size (по умолчанию 16)\n",
    "        - shuffle (по умолчанию False)\n",
    "        - num_workers (по умолчанию 2)\n",
    "        - drop_last (по умолчанию False)\n",
    "    train_transforms : T.Compose\n",
    "      Трансформации для обучающей части. По умолчанию None.\n",
    "    val_transforms : T.Compose\n",
    "      Трансформации для валидационной части. По умолчанию None.\n",
    "    seed : int\n",
    "      Фиксация генератора случайных чисел.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, dataset_class, name, train_loader_params=None, val_loader_params=None, \n",
    "                 train_transforms=None, val_transforms=None, seed=None):\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "        if seed is not None:\n",
    "            set_seed(seed)\n",
    "            \n",
    "        self._dataset_class = dataset_class\n",
    "        self._name = name\n",
    "\n",
    "        if not train_loader_params:\n",
    "            train_loader_params = {\n",
    "                'batch_size': 16,\n",
    "                'shuffle': True,\n",
    "                'num_workers': 2,\n",
    "                'drop_last': True,\n",
    "            }\n",
    "\n",
    "        if not val_loader_params:\n",
    "            val_loader_params = {\n",
    "                'batch_size': 16,\n",
    "                'shuffle': False,\n",
    "                'num_workers': 2,\n",
    "                'drop_last': False\n",
    "            }\n",
    "\n",
    "        self.train_loader_params = train_loader_params\n",
    "        self.val_loader_params = val_loader_params\n",
    "        \n",
    "        self._train_transforms = train_transforms\n",
    "        self._val_transforms = val_transforms\n",
    "        \n",
    "    def setup(self, stage=None):\n",
    "        \n",
    "        dataset_params_sig = inspect.signature(self._dataset_class.__init__)\n",
    "        if 'train' in dataset_params_sig.parameters.keys():\n",
    "            \n",
    "            train_split_params = {\n",
    "                'train': True,\n",
    "            }\n",
    "            val_split_params = {\n",
    "                'train': False,\n",
    "            }\n",
    "        else:\n",
    "            train_split_params = {\n",
    "                'split': 'train',\n",
    "            }\n",
    "            val_split_params = {\n",
    "                'split': 'test',\n",
    "            }\n",
    "        \n",
    "        self._train_dataset = self._dataset_class(self._name, download=True, transform=self._train_transforms,\n",
    "                                                  **train_split_params)\n",
    "        self._val_dataset = self._dataset_class(self._name, download=True, transform=self._val_transforms, **val_split_params)\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return DataLoader(self._train_dataset, batch_size=self.train_loader_params['batch_size'],\n",
    "                          shuffle=self.train_loader_params['shuffle'], drop_last=self.train_loader_params['drop_last'],\n",
    "                          num_workers=self.train_loader_params['num_workers'])\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return DataLoader(self._val_dataset, batch_size=self.val_loader_params['batch_size'],\n",
    "                          drop_last=self.val_loader_params['drop_last'], shuffle=self.val_loader_params['shuffle'],\n",
    "                          num_workers=self.val_loader_params['num_workers'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c46ba2a",
   "metadata": {},
   "source": [
    "#### 1.1.3 Класс HybridModel\n",
    "\n",
    "Данный класс предназначен для удобного проведения эксперимента в рамках данной домашней работы.\n",
    "\n",
    "Мы можем инициализировать любую модель из коллекции фреймворка timm и создать для нее два разных полносвязных слоя, которые можно менять на лету.\n",
    "\n",
    "Пример инициализации модели:\n",
    "\n",
    "> model = HybridModel(model_name='resnet18', fc_size_model1=101, fc_size_model2=10, pretrained=False, learning_rate=0.001)\n",
    "\n",
    "Для проведения эксперимента реализованы следующие методы:\n",
    "\n",
    "- set_fc_imagenet (возвращаем исходную полносвязную сеть исходной модели)\n",
    "- set_fc_model1 (устанавливаем полносвязный слой для модели №1, размер выхода указывается в параметре fc_size_model1)\n",
    "- set_fc_model2 (устанавливаем полносвязный слой для модели №2, размер выхода указывается в параметре fc_size_model2)\n",
    "- freeze_layers (заморозка градиента от начала модели вплоть до указанного layer_name без него самого)\n",
    "- unfreeze_all (разморозка градиентов всей модели)\n",
    "- init_opt_parameters (можно указать какие параметры будут передаваться в оптимизатор, все или только параметры полносвязной сети)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cfc7e4dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class HybridModel(pl.LightningModule):\n",
    "    \"\"\" Модель для обучения гибридной модели.\n",
    "    \n",
    "    Позволяет переключать на лету слой полносвязной сети для двух вариантов модели.\n",
    "    А также позволяет заморозить определенные слои модели и определить какие параметры\n",
    "    пойдут в омтимизатор.\n",
    "    \n",
    "    По умолчанию полносвязный слой устанавливается размером из параметра fc_size_model1\n",
    "    и в оптимизатор подаются все параметры модели.\n",
    "    \n",
    "    \n",
    "    Параметры\n",
    "    ---------\n",
    "    model_name : str\n",
    "      Название модели (должен поддерживать фреймворк timm).\n",
    "      По умолчанию resnet18\n",
    "    fc_size_model1 : int\n",
    "      Размер полносвязного слоя на выходе для модели 1\n",
    "    fc_size_model2 : int\n",
    "      Размер полносвязного слоя на выходе для модели 2\n",
    "    pretrained : bool\n",
    "      Если True, то будут загружены веса для предварительно обученной модели\n",
    "      По умолчанию True.\n",
    "    learning_rate : float\n",
    "      Скорость обучения модели. По умолчанию 0.001.\n",
    "    l2_regularization : float\n",
    "      Размер L2-регуляризации, по умолчанию 0.01\n",
    "    adam_betas : tuple\n",
    "      Коэффициенты для оптимизатора Adam.\n",
    "      По умолчанию (0.99, 0.999).\n",
    "    plot_epoch_loss : bool\n",
    "      Если True, то после каждой эпохи обучения и валидации будет выводиться график с результатами обучения\n",
    "    seed : int\n",
    "    \"\"\"\n",
    "    def __init__(self, model_name: str='resnet18', fc_size_model1: int=40, fc_size_model2: int=10, pretrained: bool =True, \n",
    "                 learning_rate: float = 0.001, l2_regularization: float = 0.01, adam_betas: (float, float) = (0.99, 0.999), \n",
    "                 plot_epoch_loss: bool = True, seed: int = None):\n",
    "        \n",
    "        super().__init__()\n",
    "        \n",
    "        if seed is not None:\n",
    "            set_seed(seed)\n",
    "        \n",
    "        self._model = timm.create_model(model_name, pretrained=pretrained)\n",
    "        \n",
    "        if 'fc' in self._model.__dir__():\n",
    "            self.__fc_name = 'fc'\n",
    "            current_fc = self._model.fc\n",
    "            fc_in_features = self._model.fc.in_features\n",
    "        elif 'head' in self._model.__dir__():\n",
    "            self.__fc_name = 'head'\n",
    "            current_fc = self._model.head\n",
    "            fc_in_features = self._model.head.in_features\n",
    "        elif 'classifier' in self._model.__dir__():\n",
    "            self.__fc_name = 'classifier'\n",
    "            if isinstance(self._model.classifier, nn.Linear):\n",
    "                current_fc = self._model.classifier\n",
    "                fc_in_features = self._model.classifier.in_features\n",
    "            else:\n",
    "                # Обычно модели с блоком classifier содержат последовательность слоев.\n",
    "                # Бывает такое, что первым слоем идет Dropout и у него нет параметра in_features\n",
    "                try:\n",
    "                    current_fc = self._model.classifier[0]\n",
    "                    fc_in_features = self._model.classifier[0].in_features\n",
    "                except:\n",
    "                    current_fc = self._model.classifier[1]\n",
    "                    fc_in_features = self._model.classifier[1].in_features\n",
    "        else:\n",
    "            raise Exception(\"В модели не найден блок полносвязной сети\")\n",
    "        \n",
    "        self._fc_layers_dict = {\n",
    "            'model1': nn.Linear(fc_in_features, fc_size_model1),\n",
    "            'model2': nn.Linear(fc_in_features, fc_size_model2),\n",
    "            'imagenet': current_fc,\n",
    "        }\n",
    "        \n",
    "        \n",
    "        # Заменяем у модели полносвязный слой на сгенерированный\n",
    "        setattr(self._model, self.__fc_name, self._fc_layers_dict['model1'])\n",
    "        \n",
    "        # Устанавливаем тип модели, требуется для корректной смены полносвязных слоев\n",
    "        self.__model_type = 'model1'\n",
    "        self.__opt_params_type = 'full'\n",
    "        self.init_opt_parameters(params_type=self.__opt_params_type)\n",
    "        \n",
    "        self.plot_epoch_loss = plot_epoch_loss\n",
    "        self.learning_rate = learning_rate\n",
    "        self.l2_regularization = l2_regularization\n",
    "        self.adam_betas = adam_betas\n",
    "        \n",
    "        self.init_train_stats()\n",
    "\n",
    "        self.save_hyperparameters()\n",
    "        \n",
    "    def init_train_stats(self):\n",
    "        # Словарь для хранения значения ошибок на стадии обучения и валидации\n",
    "        # Для значений типа train добавляем значение np.nan, так как при первом запуске модель вначале осуществляет\n",
    "        # шаг валидации без обучения и добавляет значения в списки типа val. Это будет считаться эпохой №0.\n",
    "        self.train_history = {\n",
    "            'train_loss': [np.nan],\n",
    "            'train_acc': [np.nan],\n",
    "            'val_loss': [],\n",
    "            'val_acc': [],\n",
    "        }\n",
    "        \n",
    "    def init_opt_parameters(self, params_type='full'):\n",
    "        \"\"\" Инициализируем параметры модели для подачи в омтимизатор\n",
    "        \n",
    "        Параметры\n",
    "        ---------\n",
    "        params_type : str\n",
    "          Тип параметров для оптимизатора.\n",
    "          Принимает значения full или fc.\n",
    "          В случае fc в оптимизатор пойдут только параметры полносвязного слоя.\n",
    "        \"\"\"\n",
    "        \n",
    "        params_type = str(params_type).strip().lower()\n",
    "        assert params_type in ('full', 'fc')\n",
    "        \n",
    "        if params_type == 'full':\n",
    "            self._opt_parameters = self._model.parameters()\n",
    "        else:\n",
    "            self._opt_parameters = getattr(self._model, self.__fc_name).parameters()\n",
    "            \n",
    "        self.__opt_params_type = params_type\n",
    "        \n",
    "    def freeze_layers(self, layer_name: str):\n",
    "        \"\"\" Заморозка градиента от начала модели \n",
    "        вплоть до указанного layer_name без него самого\n",
    "        \n",
    "        Параметры\n",
    "        ---------\n",
    "        layer_name : str\n",
    "          Название слоя, вплоть до которого нужно выполнить заморозку\n",
    "        \"\"\"\n",
    "        \n",
    "        all_layers_names = [name for name, _ in self._model.named_modules()]\n",
    "        assert layer_name in all_layers_names, \"Указанный слой отсутствует в модели\"\n",
    "        \n",
    "        for param_name, param in self._model.named_parameters():\n",
    "            \n",
    "            if layer_name in param_name:\n",
    "                break\n",
    "                \n",
    "            # Не выключаем обучение параметров у всех блоков Batch Normalization\n",
    "                if 'bn' in name:\n",
    "                    continue\n",
    "                    \n",
    "            param.requires_grad = False\n",
    "            \n",
    "        # При изменении параметра requires_grad требуется инициализация \n",
    "        # параметров оптимизатора, так как предыдущие параметры исчезают\n",
    "        self.init_opt_parameters(params_type=self.__opt_params_type)\n",
    "            \n",
    "    def unfreeze_all(self):\n",
    "        \"\"\" Разморозка градиентов всей модели \"\"\"\n",
    "        \n",
    "        for param_name, param in self._model.named_parameters():\n",
    "            param.requires_grad = True\n",
    "            \n",
    "        # При изменении параметра requires_grad требуется инициализация \n",
    "        # параметров оптимизатора, так как предыдущие параметры исчезают\n",
    "        self.init_opt_parameters(params_type=self.__opt_params_type)\n",
    "        \n",
    "    def _set_fc(self, model_type):\n",
    "        \"\"\" Смена полносвязной сети на выходе модели\n",
    "        \n",
    "        Параметры\n",
    "        ---------\n",
    "        model_type : str\n",
    "          Тип модели. Принимает значения model1, model2 или imagenet\n",
    "        \"\"\"\n",
    "        \n",
    "        model_type = str(model_type).strip().lower()\n",
    "        assert model_type in ('model1', 'model2', 'imagenet')\n",
    "        \n",
    "        if not self.__fc_name == 'classifier':\n",
    "            setattr(self._model, self.__fc_name, self._fc_layers_dict[model_type])\n",
    "        else:\n",
    "            if isinstance(self._model.classifier, nn.Linear) or isinstance(self._model.classifier[0], nn.Linear):\n",
    "                setattr(self._model, self.__fc_name, self._fc_layers_dict[model_type])\n",
    "            else:\n",
    "                self._model.classifier[1] = self._fc_layers_dict[model_type]\n",
    "            \n",
    "        self.__model_type = model_type\n",
    "            \n",
    "    def set_fc_imagenet(self):\n",
    "        \"\"\" Устанавливаем в качестве полносвязной сети слой от ImageNet\n",
    "        \n",
    "        Текущий полносвязный слой с его весами сохраняется и его можно вернуть\n",
    "        с помощью такого же метода для другой сети\n",
    "        \"\"\"\n",
    "        self._set_fc(model_type='imagenet')\n",
    "            \n",
    "    def set_fc_model1(self):\n",
    "        \"\"\" Устанавливаем в качестве полносвязной сети слой от Model1\n",
    "        \n",
    "        Текущий полносвязный слой с его весами сохраняется и его можно вернуть\n",
    "        с помощью такого же метода для другой сети\n",
    "        \"\"\"\n",
    "        self._set_fc(model_type='model1')\n",
    "        \n",
    "    def set_fc_model2(self):\n",
    "        \"\"\" Устанавливаем в качестве полносвязной сети слой от Model2\n",
    "        \n",
    "        Текущий полносвязный слой с его весами сохраняется и его можно вернуть\n",
    "        с помощью такого же метода для другой сети\n",
    "        \"\"\"\n",
    "        self._set_fc(model_type='model2')\n",
    "        \n",
    "    def forward(self, x_in: torch.tensor):\n",
    "        forward_data = self._model(x_in)\n",
    "        return forward_data\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        \"\"\"Конфигурация оптимизатора и планировщика скорости обучения\"\"\"\n",
    "            \n",
    "        optimizer = optim.AdamW(self._opt_parameters, betas=self.adam_betas, lr=self.learning_rate,\n",
    "                                weight_decay=self.l2_regularization)\n",
    "        sheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer,\n",
    "                                                                  T_0=20,\n",
    "                                                                  eta_min=1e-4)\n",
    "\n",
    "        return [optimizer], [sheduler]\n",
    "\n",
    "    def _share_step(self, batch: dict, batch_idx: int, mode: str = 'train'):\n",
    "        \"\"\" Общий шаг для обучения, валидации и теста\n",
    "        Параметры\n",
    "        ---------\n",
    "        batch : dict\n",
    "          Батч-словарь в следующем формате:\n",
    "          {\n",
    "          'img': список тензоров изображения размером N x C x H x W,\n",
    "          'image_path': список путей к файлам изображений,\n",
    "          'target': список целевых значений,\n",
    "          'parrot_name': список человекочитаемых имен попугаев,\n",
    "          }\n",
    "        batch_idx : int\n",
    "          Номер батча\n",
    "        mode : str\n",
    "          Режим. Используется только для префикса названий ошибок в логе.\n",
    "          По умолчанию train\n",
    "        \"\"\"\n",
    "\n",
    "        # Датасет CIFAR10 генерирует кортежи\n",
    "        # Датасет ImageNette генерирует словари\n",
    "        if isinstance(batch, dict):\n",
    "            batch_images = batch['image']\n",
    "            target_true = batch['target']\n",
    "        else:\n",
    "            batch_images, target_true = batch\n",
    "            \n",
    "        target_pred = self(batch_images)\n",
    "\n",
    "        # Считаем ошибку Binary Cross Entropy и логируем ее\n",
    "        cross_entropy_loss = F.cross_entropy(target_pred, target_true)\n",
    "        self.log(f'cross_entropy_{mode}_loss', cross_entropy_loss, prog_bar=True)\n",
    "        \n",
    "        acc_loss = accuracy_score(target_true.detach().cpu(), np.argmax(target_pred.detach().cpu(), axis=1).flatten())\n",
    "        self.log(f'acc_{mode}_loss', acc_loss, prog_bar=True)\n",
    "\n",
    "        return {'loss': cross_entropy_loss, 'acc_loss': acc_loss}\n",
    "\n",
    "    def training_step(self, batch: dict, batch_idx: int):\n",
    "        \"\"\"Шаг обучения\"\"\"\n",
    "        return self._share_step(batch, batch_idx, mode='train')\n",
    "\n",
    "    def training_epoch_end(self, outputs: list):\n",
    "        \"\"\"Действия после окончания каждой эпохи обучения\n",
    "        Параметры\n",
    "        ---------\n",
    "        outputs : list\n",
    "          Список словарей. Каждый словарь - результат функции self._share_step для определенного батча на шаге обучения\n",
    "        \"\"\"\n",
    "\n",
    "        # Считаем средние ошибки loss и acc_loss по эпохе\n",
    "        avg_train_loss = torch.tensor([x['loss'] for x in outputs]).detach().mean()\n",
    "        avg_acc_loss = torch.tensor([x['acc_loss'] for x in outputs]).detach().mean()\n",
    "\n",
    "        # Добавляем средние ошибки в словарь статистики обучения, используется для построение графиков\n",
    "        self.train_history['train_loss'].append(avg_train_loss.numpy().item())\n",
    "        self.train_history['train_acc'].append(avg_acc_loss.numpy().item())\n",
    "\n",
    "        # Если включено отображение графика обучения в конце эпохи, то рисуем графики\n",
    "        if self.plot_epoch_loss:\n",
    "            self.plot_history_loss()\n",
    "\n",
    "    def validation_step(self, batch: dict, batch_idx: int):\n",
    "        \"\"\" Шаг валидации \"\"\"\n",
    "        return self._share_step(batch, batch_idx, mode='val')\n",
    "\n",
    "    def validation_epoch_end(self, outputs: list):\n",
    "        \"\"\"Действия после окончания каждой эпохи валидации\n",
    "        Параметры\n",
    "        ---------\n",
    "        outputs : list\n",
    "          Список словарей.\n",
    "          Каждый словарь - результат функции self._share_step для определенного батча на шаге валидации\n",
    "        \"\"\"\n",
    "\n",
    "        # Считаем средние ошибки loss и rmse_loss по эпохе\n",
    "        avg_val_loss = torch.tensor([x['loss'] for x in outputs]).detach().mean()\n",
    "        avg_acc_loss = torch.tensor([x['acc_loss'] for x in outputs]).detach().mean()\n",
    "        \n",
    "        # Логируем ошибку валидации\n",
    "        self.log(f'val_loss', avg_val_loss, prog_bar=True)\n",
    "\n",
    "        # Добавляем средние ошибки в словарь статистики обучения, используется для построение графиков\n",
    "        self.train_history['val_loss'].append(avg_val_loss.numpy().item())\n",
    "        self.train_history['val_acc'].append(avg_acc_loss.numpy().item())\n",
    "\n",
    "        # Если включено отображение графика обучения в конце эпохи, то рисуем графики\n",
    "        if self.plot_epoch_loss:\n",
    "            self.plot_history_loss()\n",
    "\n",
    "    def plot_history_loss(self, clear_output: bool = True):\n",
    "        \"\"\" Функция построения графика обучения в конце эпохи\n",
    "        \n",
    "        Параметры\n",
    "        clear_output : bool\n",
    "          Если True, то после каждой эпохи график будет обновляться,\n",
    "          а не печататься новый.\n",
    "        \"\"\"\n",
    "\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(15, 5))\n",
    "\n",
    "        axes[0].plot(np.arange(0, len(self.train_history['train_loss'])),\n",
    "                     self.train_history['train_loss'],\n",
    "                     label=\"train_loss\")\n",
    "        axes[0].scatter(np.arange(0, len(self.train_history['train_loss'])),\n",
    "                     self.train_history['train_loss'])\n",
    "        axes[0].plot(np.arange(0, len(self.train_history['val_loss'])),\n",
    "                     self.train_history['val_loss'],\n",
    "                     label=\"val_loss\")\n",
    "        axes[0].scatter(np.arange(0, len(self.train_history['val_loss'])),\n",
    "                     self.train_history['val_loss'])\n",
    "        axes[0].legend(loc='best')\n",
    "        axes[0].set_xlabel(\"epochs\")\n",
    "        axes[0].set_ylabel(\"loss\")\n",
    "        if len(self.train_history['val_loss'])> 1:\n",
    "            val_loss_epoch_min = np.argmin(self.train_history['val_loss'][1:]) + 1\n",
    "            val_loss_min = self.train_history['val_loss'][val_loss_epoch_min]\n",
    "            val_loss_min = round(val_loss_min, 3) if not np.isnan(val_loss_min) else val_loss_min\n",
    "            title_min_vals = f'\\nValidation minimum {val_loss_min} on epoch {val_loss_epoch_min}'\n",
    "        else:\n",
    "            title_min_vals = \"\"\n",
    "        axes[0].set_title('MODEL LOSS: CROSS ENTROPY'+title_min_vals)\n",
    "        axes[0].grid()\n",
    "\n",
    "        axes[1].plot(np.arange(0, len(self.train_history['train_acc'])),\n",
    "                     self.train_history['train_acc'], label=\"train_acc\")\n",
    "        axes[1].scatter(np.arange(0, len(self.train_history['train_acc'])),\n",
    "                     self.train_history['train_acc'])\n",
    "        axes[1].plot(np.arange(0, len(self.train_history['val_acc'])),\n",
    "                     self.train_history['val_acc'], label=\"val_acc\")\n",
    "        axes[1].scatter(np.arange(0, len(self.train_history['val_acc'])),\n",
    "                     self.train_history['val_acc'])\n",
    "        axes[1].legend(loc='best')\n",
    "        axes[1].set_xlabel(\"epochs\")\n",
    "        axes[1].set_ylabel(\"accuracy\")\n",
    "        \n",
    "        if len(self.train_history['val_acc'])> 1:\n",
    "            val_acc_epoch_max = np.argmax(self.train_history['val_acc'][1:]) + 1\n",
    "            val_acc_max = self.train_history['val_acc'][val_acc_epoch_max]\n",
    "            val_acc_max = round(val_acc_max, 3) if not np.isnan(val_acc_max) else val_acc_max\n",
    "            title_max_vals = f'\\nValidation maximum {val_acc_max} on epoch {val_acc_epoch_max}'\n",
    "        else:\n",
    "            title_max_vals = \"\"\n",
    "        axes[1].set_title('MONITORING LOSS: Accuracy'+title_max_vals)\n",
    "        axes[1].grid()\n",
    "\n",
    "        plt.show()\n",
    "        if clear_output:\n",
    "            display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d502d3",
   "metadata": {},
   "source": [
    "### 1.2 Обучение модели на датасете Food101\n",
    "\n",
    "Для части датасета обучения включим случайную аугментацию, а также нормализуем с помощью средних и СКО от датасета ImageNet.\n",
    "\n",
    "Полносвязный слой для Food101 должен иметь 101 выход, поэтому fc_size_model1 = 101. А полносвязный слой для STL10 должен иметь 10 выходов, поэтому fc_size_model2 = 10. \n",
    "\n",
    "В качестве модели выберем resnet18."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f54ac969",
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 42\n",
    "\n",
    "train_transforms = T.Compose(\n",
    "                [\n",
    "                 T.Resize([96, 96]),\n",
    "                 T.RandAugment(),\n",
    "                 T.PILToTensor(),\n",
    "                 T.ConvertImageDtype(torch.float32),\n",
    "                 T.Normalize(std=(0.229, 0.224, 0.225), mean=(0.485, 0.456, 0.406)),\n",
    "                ]\n",
    "        )\n",
    "\n",
    "val_transforms = T.Compose(\n",
    "                [\n",
    "                 T.Resize([96, 96]),\n",
    "                 T.PILToTensor(),\n",
    "                 T.ConvertImageDtype(torch.float32),\n",
    "                 T.Normalize(std=(0.229, 0.224, 0.225), mean=(0.485, 0.456, 0.406)),\n",
    "                ]\n",
    "        )\n",
    "\n",
    "config_model = {'seed': SEED,\n",
    "    'model': {\n",
    "        'model_name': 'resnet18',\n",
    "        'fc_size_model1': 101,\n",
    "        'fc_size_model2': 10,\n",
    "        'plot_epoch_loss': True,\n",
    "        'learning_rate': 0.0001, \n",
    "        'l2_regularization': 0.01,\n",
    "        'adam_betas': (0.99, 0.999),\n",
    "        'pretrained': False,\n",
    "        'seed': SEED,\n",
    "    },\n",
    "    'trainer': {\n",
    "        'max_epochs': 300,\n",
    "        'gpus': 1 if torch.cuda.is_available() else 0,\n",
    "        'resume_from_checkpoint': None,\n",
    "    },\n",
    "}\n",
    "\n",
    "food101_config_dataset = {\n",
    "    'seed': SEED,\n",
    "    'dataset_class': Food101,\n",
    "    'name': 'food101',\n",
    "    'train_transforms': train_transforms,\n",
    "    'val_transforms': val_transforms,\n",
    "    'train_loader_params': {\n",
    "        'batch_size': 16,\n",
    "        'shuffle': True,\n",
    "        'num_workers': 0,\n",
    "        'pin_memory': False,\n",
    "        'drop_last': True,\n",
    "    },\n",
    "    'val_loader_params': {\n",
    "        'batch_size': 16,\n",
    "        'shuffle': False,\n",
    "        'num_workers': 0,\n",
    "        'pin_memory': False,\n",
    "        'drop_last': False\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fbc8465f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n"
     ]
    }
   ],
   "source": [
    "hybrid_model = HybridModel(**config_model['model'])\n",
    "\n",
    "\n",
    "food101_datamodule = StandardTorchDataModule(**food101_config_dataset)\n",
    "\n",
    "checkpoint = ModelCheckpoint(dirpath='checkpoint_first_model/', monitor='acc_val_loss', mode='max')\n",
    "callbacks = [\n",
    "            EarlyStopping('acc_val_loss', min_delta=0.001, patience=5, mode='max'),\n",
    "            TQDMProgressBar(refresh_rate=10),\n",
    "            checkpoint\n",
    "]\n",
    "\n",
    "trainer = pl.Trainer(**config_model['trainer'], callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "abe300d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.fit(hybrid_model, food101_datamodule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "40d43d35",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Загружаем модель с лучшим accuracy и сохраняем ее веса на диске\n",
    "\n",
    "hybrid_model = HybridModel.load_from_checkpoint(checkpoint.best_model_path)\n",
    "torch.save(hybrid_model.state_dict(), f'best_model_food101.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c414419a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a74c277ede1745d184201ecdc0cc902c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1579 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score 0.4963584547181761\n"
     ]
    }
   ],
   "source": [
    "model_accuracy = check_model_accuracy(hybrid_model, food101_datamodule.val_dataloader())\n",
    "print('Accuracy Score', model_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2322b830",
   "metadata": {},
   "source": [
    "В результате мы получили значение accuracy = 0.496 на валидационной части датасета.\n",
    "\n",
    "## 2 Адаптация модели для обучения на датасете STL10 (TransferLearning и Fine-Tuning)\n",
    "\n",
    "Что требуется сделать:\n",
    "\n",
    "- сохранить у модели текущий полносвязный слой от модели Food101\n",
    "- заменить у модели полносвязный слой на новый для датасета STL10\n",
    "- заморозить градиент для 80% модели\n",
    "- обучить модель с частично замороженными градиентами на датасете STL10\n",
    "- разморозить все слои модели и дообучить ее на 5 эпохах на датасете STL10\n",
    "- вернуть ранее обученный полносвязный слой от датасета Food101 и проверить качество модели\n",
    "- дообучить только полносвязную сеть на датасете Food101 и снова проверить качество модели"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e6b01e6",
   "metadata": {},
   "source": [
    "### 2.1 Проведение эксперимента\n",
    "\n",
    "#### 2.2.1 Обучение модели на датасете STL10\n",
    "\n",
    "Возьмем модель, которую мы раньше обучили на датасете Food101 и заморозим все градиенты модели, которые предшествуют уровню с именем \"layer3\". Дообучим модель на датасете STL10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ad0f44d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transforms = T.Compose(\n",
    "                [\n",
    "                 T.RandAugment(),\n",
    "                 T.PILToTensor(),\n",
    "                 T.ConvertImageDtype(torch.float32),\n",
    "                 T.Normalize(std=(0.229, 0.224, 0.225), mean=(0.485, 0.456, 0.406)),\n",
    "                ]\n",
    "        )\n",
    "\n",
    "val_transforms = T.Compose(\n",
    "                [\n",
    "                 T.PILToTensor(),\n",
    "                 T.ConvertImageDtype(torch.float32),\n",
    "                 T.Normalize(std=(0.229, 0.224, 0.225), mean=(0.485, 0.456, 0.406)),\n",
    "                ]\n",
    "        )\n",
    "\n",
    "stl10_config_dataset = {\n",
    "    'seed': SEED,\n",
    "    'dataset_class': STL10,\n",
    "    'name': 'stl10',\n",
    "    'train_transforms': train_transforms,\n",
    "    'val_transforms': val_transforms,\n",
    "    'train_loader_params': {\n",
    "        'batch_size': 16,\n",
    "        'shuffle': True,\n",
    "        'num_workers': 0,\n",
    "        'pin_memory': False,\n",
    "        'drop_last': True,\n",
    "    },\n",
    "    'val_loader_params': {\n",
    "        'batch_size': 16,\n",
    "        'shuffle': False,\n",
    "        'num_workers': 0,\n",
    "        'pin_memory': False,\n",
    "        'drop_last': False\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5eb432fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n"
     ]
    }
   ],
   "source": [
    "# Устанавливаем полносвязный слой для STL10\n",
    "hybrid_model.set_fc_model2()\n",
    "\n",
    "# Замораживаем градиенты на всех слоях до layer3 не включительно\n",
    "hybrid_model.freeze_layers('layer3')\n",
    "\n",
    "# Сбрасываем статистику обучения для графика\n",
    "hybrid_model.init_train_stats()\n",
    "\n",
    "slt10_datamodule = StandardTorchDataModule(**stl10_config_dataset)\n",
    "\n",
    "checkpoint = ModelCheckpoint(dirpath='checkpoint_second_model/', monitor='acc_val_loss', mode='max')\n",
    "callbacks = [\n",
    "            EarlyStopping('acc_val_loss', min_delta=0.005, patience=5, mode='max'),\n",
    "            TQDMProgressBar(refresh_rate=10),\n",
    "            checkpoint\n",
    "]\n",
    "\n",
    "trainer = pl.Trainer(**config_model['trainer'], callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "14df14ff",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.fit(hybrid_model, slt10_datamodule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d16d2171",
   "metadata": {},
   "source": [
    "Наблюдаем сильное переобучение у сети. При этом веса предобученной модели помогли учиться лучше, так как без предобучения модель на первой эпохе дает результат на валидации примерно 0.2 accuracy. Модель не откатываем к наилучшим весам, так как для нашего эксперимента чем больше эпох, тем лучше проявится эффект \"катастрофического забывания\".\n",
    "\n",
    "Теперь разморозим все слои модели и обучим ее на датасете STL10 в течении 5 эпох"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "994e8291",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n"
     ]
    }
   ],
   "source": [
    "config_model['trainer']['max_epochs'] = 5\n",
    "\n",
    "hybrid_model.unfreeze_all()\n",
    "\n",
    "slt10_datamodule = StandardTorchDataModule(**stl10_config_dataset)\n",
    "\n",
    "callbacks = [\n",
    "            TQDMProgressBar(refresh_rate=10),\n",
    "]\n",
    "\n",
    "trainer = pl.Trainer(**config_model['trainer'], callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "371af5b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.fit(hybrid_model, slt10_datamodule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e45e575b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aec0cd5ae36b4471b80b8707f1072e21",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score 0.740375\n"
     ]
    }
   ],
   "source": [
    "model_accuracy = check_model_accuracy(hybrid_model, slt10_datamodule.val_dataloader())\n",
    "print('Accuracy Score', model_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "720c96b7",
   "metadata": {},
   "source": [
    "#### 2.2.2 Дообучение модели на датасете Food101\n",
    "\n",
    "Теперь вернем для модели полносвязный слой для датасета Food101 и проверим Accuracy Score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3e6cf9ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f69ba414e8541f793876037bc84e70e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1579 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score 0.14514724509183027\n"
     ]
    }
   ],
   "source": [
    "# Возвращаем полносвязный слой от Food101\n",
    "hybrid_model.set_fc_model1()\n",
    "\n",
    "# Переводим модель в режим валидации\n",
    "hybrid_model.eval()\n",
    "\n",
    "model_accuracy = check_model_accuracy(hybrid_model, food101_datamodule.val_dataloader())\n",
    "print('Accuracy Score', model_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35423487",
   "metadata": {},
   "source": [
    "В результате модель разучилась предсказывать данные на Food101, получили значение accuracy 0.145 против 0.496 при изначальном обучении.\n",
    "\n",
    "Чтобы это исправить и попробовать увидеть проблему \"катастрофического забывания\", дообучим у модели только полносвязный слой на датасете Food101."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "875c88d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n"
     ]
    }
   ],
   "source": [
    "config_model['trainer']['max_epochs'] = 100\n",
    "\n",
    "# Замораживаем градиенты на всех слоях до fc не включительно\n",
    "hybrid_model.freeze_layers('fc')\n",
    "\n",
    "# В оптимизатор передаем только полносвязный слой\n",
    "hybrid_model.init_opt_parameters('fc')\n",
    "\n",
    "# Сбрасываем статистику обучения для графика\n",
    "hybrid_model.init_train_stats()\n",
    "\n",
    "callbacks = [\n",
    "            EarlyStopping('acc_val_loss', min_delta=0.001, patience=5, mode='max'), \n",
    "            TQDMProgressBar(refresh_rate=10),\n",
    "]\n",
    "\n",
    "trainer = pl.Trainer(**config_model['trainer'], callbacks=callbacks)\n",
    "food101_datamodule = StandardTorchDataModule(**food101_config_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "46f59d10",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.fit(hybrid_model, food101_datamodule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3501e180",
   "metadata": {},
   "source": [
    "Вернув модели полносвязный слой от Food101 и обучив только его на данном датасете нам не удалось добитться прежнего качества модели accuracy 0.496 против 0.415.\n",
    "\n",
    "# Результаты\n",
    "В домашней работе провели эксперимент и смогли показать наличие проблемы \"катастрофического забывания\"."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
